// AI模型配置工具类

// 定义AI模型类型
export type AIModelType = 'deepseek-r1' | 'doubao' | 'tongyiqianwen' | 'chatgpt';

// 定义单个模型配置接口
export interface ModelSpecificConfig {
  apiKey: string;
  apiBase: string;
}

// 定义AI模型配置接口
export interface AIModelConfig {
  defaultModel: AIModelType;
  models: Record<AIModelType, ModelSpecificConfig>;
  timeout: number;
}

// 默认配置
const defaultConfig: AIModelConfig = {
  defaultModel: 'deepseek-r1',
  models: {
    'deepseek-r1': {
      apiKey: '',
      apiBase: 'https://api.deepseek.com'
    },
    'doubao': {
      apiKey: '',
      apiBase: 'https://api.doubao.com'
    },
    'tongyiqianwen': {
      apiKey: '',
      apiBase: 'https://api.tongyi.aliyun.com'
    },
    'chatgpt': {
      apiKey: '',
      apiBase: 'https://api.openai.com'
    }
  },
  timeout: 300
};

/**
 * AI模型配置管理类
 */
export class AIModelConfigManager {
  private static instance: AIModelConfigManager;
  private config: AIModelConfig;
  private storageKey = 'aiModelSettings';

  private constructor() {
    this.config = this.getDefaultConfig();
    this.loadConfig();
  }
    
  /**
   * 获取默认配置
   */
  private getDefaultConfig(): AIModelConfig {
    return {
      defaultModel: 'deepseek-r1',
      models: {
        'deepseek-r1': {
          apiKey: '',
          apiBase: 'https://api.deepseek.com'
        },
        'doubao': {
          apiKey: '',
          apiBase: 'https://api.doubao.com'
        },
        'tongyiqianwen': {
          apiKey: '',
          apiBase: 'https://api.tongyi.aliyun.com'
        },
        'chatgpt': {
          apiKey: '',
          apiBase: 'https://api.openai.com'
        }
      },
      timeout: 300
    };
  }

  /**
   * 获取单例实例
   */
  public static getInstance(): AIModelConfigManager {
    if (!AIModelConfigManager.instance) {
      AIModelConfigManager.instance = new AIModelConfigManager();
    }
    return AIModelConfigManager.instance;
  }

  /**
   * 从localStorage加载配置
   */
  private loadConfig(): void {
    try {
      const savedConfig = localStorage.getItem(this.storageKey);
      if (savedConfig) {
        // 处理旧配置格式的兼容
        const parsedConfig = JSON.parse(savedConfig);
        // 如果是旧格式，转换为新格式
        if (parsedConfig.deepseekApiKey !== undefined) {
          this.config = {
            ...defaultConfig,
            models: {
              ...defaultConfig.models,
              'deepseek-r1': {
                apiKey: parsedConfig.deepseekApiKey,
                apiBase: parsedConfig.deepseekApiBase || defaultConfig.models['deepseek-r1'].apiBase
              }
            },
            defaultModel: parsedConfig.defaultModel || defaultConfig.defaultModel,
            timeout: parsedConfig.timeout || defaultConfig.timeout
          };
        } else {
          this.config = {
            ...defaultConfig,
            ...parsedConfig
          };
        }
      } else {
        this.config = { ...defaultConfig };
      }
    } catch (error) {
      console.error('加载AI模型配置失败:', error);
      this.config = { ...defaultConfig };
    }
  }

  /**
   * 保存配置到localStorage
   * @param newConfig 新的配置对象
   */
  public saveConfig(newConfig: Partial<AIModelConfig>): void {
    try {
      this.config = {
        ...this.config,
        ...newConfig
      };
      localStorage.setItem(this.storageKey, JSON.stringify(this.config));
    } catch (error) {
      console.error('保存AI模型配置失败:', error);
    }
  }

  /**
   * 保存特定模型的配置
   * @param model 模型类型
   * @param config 模型配置
   */
  public saveModelConfig(model: AIModelType, config: Partial<ModelSpecificConfig>): void {
    try {
      this.config.models[model] = {
        ...this.config.models[model],
        ...config
      };
      localStorage.setItem(this.storageKey, JSON.stringify(this.config));
    } catch (error) {
      console.error(`保存${model}模型配置失败:`, error);
    }
  }

  /**
   * 获取当前配置
   */
  public getConfig(): AIModelConfig {
    return { ...this.config };
  }

  /**
   * 获取默认模型
   */
  public getDefaultModel(): AIModelType {
    return this.config.defaultModel;
  }

  /**
   * 设置默认模型
   * @param model 模型类型
   */
  public setDefaultModel(model: AIModelType): void {
    this.config.defaultModel = model;
    try {
      localStorage.setItem(this.storageKey, JSON.stringify(this.config));
    } catch (error) {
      console.error('设置默认模型失败:', error);
    }
  }

  /**
   * 获取指定模型的API Key
   * @param model 模型类型，默认为当前默认模型
   */
  public getApiKey(model?: AIModelType): string {
    const targetModel = model || this.config.defaultModel;
    return this.config.models[targetModel]?.apiKey || '';
  }

  /**
   * 获取指定模型的API Base URL
   * @param model 模型类型，默认为当前默认模型
   */
  public getApiBase(model?: AIModelType): string {
    const targetModel = model || this.config.defaultModel;
    return this.config.models[targetModel]?.apiBase || '';
  }

  /**
   * 获取DeepSeek API Key（向后兼容）
   */
  public getDeepSeekApiKey(): string {
    return this.getApiKey('deepseek-r1');
  }

  /**
   * 获取DeepSeek API Base URL（向后兼容）
   */
  public getDeepSeekApiBase(): string {
    return this.getApiBase('deepseek-r1');
  }

  /**
   * 获取超时时间（毫秒）
   */
  public getTimeoutMs(): number {
    return this.config.timeout * 1000;
  }

  /**
   * 重置配置到默认值
   */
  public resetConfig(): void {
    this.config = this.getDefaultConfig();
    try {
      localStorage.setItem(this.storageKey, JSON.stringify(this.config));
    } catch (error) {
      console.error('重置AI模型配置失败:', error);
    }
  }

  /**
   * 检查配置是否有效
   * @param model 可选，指定要检查的模型
   */
  public isValidConfig(model?: AIModelType): boolean {
    const targetModel = model || this.config.defaultModel;
    const apiKey = this.getApiKey(targetModel);
    const apiBase = this.getApiBase(targetModel);
    
    // 对于所有模型，需要API Key和有效的API Base URL
    if (!apiKey || !apiBase) {
      return false;
    }
    
    // 根据不同模型类型进行特定的API Key格式验证
    switch (targetModel) {
      case 'deepseek-r1':
        // DeepSeek API Key 通常以 'sk-' 开头，至少包含30个字符
        return /^sk-[a-zA-Z0-9]{30,}$/.test(apiKey);
      case 'chatgpt':
        // OpenAI API Key 通常以 'sk-' 开头，包含51个字符
        return /^sk-[a-zA-Z0-9]{48}$/.test(apiKey);
      case 'doubao':
        // 豆包API Key 通常是32位字母数字组合
        return /^[a-zA-Z0-9]{32}$/.test(apiKey);
      case 'tongyiqianwen':
        // 通义千问API Key 通常包含字母、数字和连字符
        return apiKey.length >= 20;
      default:
        // 对于未知模型，至少确保API Key长度合理
        return apiKey.length >= 10;
    }
  }

  /**
   * 获取OpenAI客户端配置
   * 用于兼容openai-node客户端
   * @param model 可选，指定要获取配置的模型
   */
  public getOpenAIClientConfig(model?: AIModelType) {
    const targetModel = model || this.config.defaultModel;
    return {
      apiKey: this.getApiKey(targetModel),
      baseURL: this.getApiBase(targetModel),
      timeout: this.getTimeoutMs()
    };
  }

  /**
   * 获取所有可用的模型列表
   */
  public getAvailableModels(): AIModelType[] {
    return Object.keys(this.config.models) as AIModelType[];
  }
}

// 导出默认实例
export const aiModelConfig = AIModelConfigManager.getInstance();

export default aiModelConfig;